package cn.org.xwb.bookmall.admin.service.impl;

import cn.org.xwb.bookmall.admin.service.AdminProductService;
import cn.org.xwb.bookmall.admin.utils.Convert2DtoUtil;
import cn.org.xwb.bookmall.admin.utils.Convert2PoUtil;
import cn.org.xwb.bookmall.admin.vo.UploadProductVo;
import cn.org.xwb.bookmall.model.po.*;
import cn.org.xwb.bookmall.model.service.impl.*;
import cn.org.xwb.bookmall.model.vo.ProductCategoryVo;
import cn.org.xwb.bookmall.model.vo.ProductConditionVo;
import cn.org.xwb.bookmall.model.vo.ProductVo;
import cn.org.xwb.common.model.vo.RespResult;
import cn.org.xwb.common.page.dto.PageResult;
import cn.org.xwb.common.utils.DbUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.List;
import java.util.Objects;

@Service
public class AdminProductServiceImpl implements AdminProductService {

    @Autowired
    private ProductCategoryServiceImpl productCategoryService;

    @Autowired
    private ProductCategorySubServiceImpl productCategorySubService;

    @Autowired
    private ProductServiceImpl productService;

    @Autowired
    private ProductOptionsServiceImpl productOptionsService;

    @Autowired
    private ProductParamServiceImpl productParamService;

    @Autowired
    private ProductImgServiceImpl productImgService;

    @Autowired
    private ProductLabelServiceImpl productLabelService;

    /**
     * 根据 id 查询指定商品的全部相关信息
     *
     * @param id
     * @return
     */
    @Override
    public RespResult<Object> selectProductAllById(Long id) {
        ProductVo productVo = productService.selectProductAllById(id);
        if (Objects.isNull(productVo)) return RespResult.fail("获取商品详细信息失败");
        return RespResult.success("获取商品详细信息成功");
    }

    /**
     * 根据 id 删除商品(逻辑)
     *
     * @param productId
     * @return
     */
    @Override
    @Transactional
    public RespResult<Object> removeParamByProductIdLogic(Long productId) {
        // 更新商品销量
        RespResult<Object> respResult2 = updateAllProductSale();
        if (!respResult2.getStatus()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败，商品销量跟新失败");
        }
        Product product = Convert2PoUtil.genProduct(productId);
        boolean res = productService.updateById(product);
        if (!res) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败");
        }
        // 更新缓存
        productService.getAllAndCache();
        productCategoryService.findAndCacheAllWithImg();
        return RespResult.success("删除商品成功");
    }

    /**
     * 更新商品销量
     *
     * @return
     */
    @Override
    @Transactional
    public RespResult<Object> updateAllProductSale() {
        // 从缓存获取全部商品信息
        List<ProductVo> productVos = productService.findAllFromCache();
        for (ProductVo productVo : productVos) {
            Product product = Convert2PoUtil.genProduct(productVo);
            // 更新商品销量
            boolean res = productService.updateById(product);
            if (!res) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("跟新商品销量失败");
            }
        }
        return RespResult.success("跟新商品销量成功");
    }

    /**
     * 根据 id 删除商品
     *
     * @param productId
     * @return
     */
    @Override
    @Transactional
    public RespResult<Object> removeProductById(Long productId) {
        // 更新商品销量
        RespResult<Object> respResult2 = updateAllProductSale();
        if (!respResult2.getStatus()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败，商品销量跟新失败");
        }
        // 删除商品图片
        RespResult<Object> respResult = removeImgByProductId(productId);
        if (!respResult.getStatus()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败，商品图片删除失败");
        }
        // 删除商品标签
        respResult = removeLabelByProductId(productId);
        if (!respResult.getStatus()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败，商品标签删除失败");
        }
        // 删除商品选项
        respResult = removeOptionsByProductId(productId);
        if (!respResult.getStatus()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败，商品选项删除失败");
        }
        respResult = removeParamByProductId(productId);
        if (!respResult.getStatus()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品失败，商品参数删除失败");
        }
        // 商品删除
        boolean res = productService.removeById(productId);
        if (!res) return RespResult.success("删除商品失败");
        // 更新缓存
        productService.getAllAndCache();
        productCategoryService.findAndCacheAllWithImg();
        return RespResult.success("删除商品成功");
    }

    /**
     * 根据商品 id 删除商品参数
     *
     * @param productId
     * @return
     */
    @Override
    public RespResult<Object> removeParamByProductId(Long productId) {
        LambdaQueryWrapper<ProductParam> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductParam::getProductId, productId);
        boolean res = productParamService.remove(queryWrapper);
        // if (res) return RespResult.success("删除商品参数成功");
        // return RespResult.fail("删除商品参数失败");
        return RespResult.success("删除商品参数成功");
    }

    /**
     * 根据商品 id 删除商品选项
     *
     * @param productId
     * @return
     */
    @Override
    public RespResult<Object> removeOptionsByProductId(Long productId) {
        LambdaQueryWrapper<ProductOptions> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductOptions::getProductId, productId);
        boolean res = productOptionsService.remove(queryWrapper);
        // if (res) return RespResult.success("删除商品选项成功");
        // return RespResult.fail("删除商品选项失败");
        return RespResult.success("删除商品选项成功");
    }

    /**
     * 根据商品 id 删除商品标签
     *
     * @param productId
     * @return
     */
    @Override
    public RespResult<Object> removeLabelByProductId(Long productId) {
        LambdaQueryWrapper<ProductLabel> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductLabel::getProductId, productId);
        boolean res = productLabelService.remove(queryWrapper);
        // if (res) return RespResult.success("删除商品标签成功");
        // return RespResult.fail("删除商品标签失败");
        return RespResult.success("删除商品标签成功");
    }

    /**
     * 根据商品 id 删除商品图片
     *
     * @param productId
     * @return
     */
    @Override
    public RespResult<Object> removeImgByProductId(Long productId) {
        LambdaQueryWrapper<ProductImg> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductImg::getProductId, productId);
        boolean res = productImgService.remove(queryWrapper);
        // if (res) return RespResult.success("删除商品图片成功");
        // return RespResult.fail("删除商品图片失败");
        return RespResult.success("删除商品图片成功");
    }

    /**
     * 分页获取商品列表
     *
     * @param productConditionVo
     * @return
     */
    @Override
    public RespResult<Object> getProductPage(ProductConditionVo productConditionVo) {
        PageResult<List<ProductVo>> productPage = productService.findProductPage(productConditionVo);
        return RespResult.success("获取商品列表成功", productPage);
    }

    /**
     * 新增一级商品分类，如果有二级一起新增
     *
     * @param productCategory
     * @param subs
     * @return
     */
    @Override
    @Transactional
    public RespResult<Object> addProductCategory(ProductCategory productCategory, List<ProductCategorySub> subs) {
        // 判断一级分类是否可以添加
        RespResult<Object> respResult = judgeProductCategoryExists(productCategory);
        if (Objects.nonNull(respResult)) return respResult;
        // 可以添加一级分类
        boolean res = productCategoryService.save(productCategory);
        if (!res) return RespResult.fail("新增一级商品分类失败，请稍后重新尝试");
        // 一级分类添加成功
        // 添加二级分类
        for (ProductCategorySub sub : subs) {
            // 二级分类关联一级分类
            sub.setProductCategoryId(productCategory.getId());
            respResult = addProductCategorySub(sub);
            // 添加二级分类失败
            if (!respResult.getStatus()) {
                // 回滚事务
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return respResult;
            }
        }
        // 成功 刷新缓存
        productCategoryService.findAndCacheAll();
        productCategoryService.findAndCacheAllWithImg();
        return RespResult.success("新增商品分类成功");
    }

    /**
     * 新增二级商品分类
     *
     * @param productCategorySub
     * @return
     */
    @Override
    public RespResult<Object> addProductCategorySub(ProductCategorySub productCategorySub) {
        // 判断二级分类是否可以添加
        RespResult<Object> respResult = judgeProductCategorySubExists(productCategorySub);
        if (Objects.nonNull(respResult)) return respResult;
        // 可以添加二级商品分类
        boolean res = productCategorySubService.save(productCategorySub);
        if (!res) return RespResult.fail("新增二级商品分类失败，请稍后重新尝试");
        // 刷新缓存
        productCategoryService.findAndCacheAll();
        productCategoryService.findAndCacheAllWithImg();
        return RespResult.success("新增二级商品分类成功");
    }

    @Override
    public RespResult<Object> updateProductCategory(ProductCategory productCategory) {
        // 判断是否存在重复
        RespResult<Object> respResult = judgeProductCategoryExists(productCategory);
        if (Objects.nonNull(respResult)) return respResult;
        boolean res = productCategoryService.updateById(productCategory);
        if (!res) return RespResult.fail("修改一级商品分类失败，请稍后重新尝试");
        // 成功，刷新缓存
        productCategoryService.findAndCacheAll();
        productCategoryService.findAndCacheAllWithImg();
        return RespResult.success("修改一级商品分类成功");
    }

    @Override
    public RespResult<Object> updateProductCategorySub(ProductCategorySub productCategorySub) {
        // 判断是否存在
        RespResult<Object> respResult = judgeProductCategorySubExists(productCategorySub);
        if (Objects.nonNull(respResult)) return respResult;
        // 可以修改
        boolean res = productCategorySubService.updateById(productCategorySub);
        if (!res) return RespResult.fail("修改二级商品分类失败，请稍后重新尝试");
        // 成功，刷新缓存
        productCategoryService.findAndCacheAll();
        productCategoryService.findAndCacheAllWithImg();
        return RespResult.success("修改二级商品分类成功");
    }

    @Override
    @Transactional
    public RespResult<Object> deleteProductCategory(Long id, Long toId) {
        // 查询是否有二级分类存在
        LambdaQueryWrapper<ProductCategorySub> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductCategorySub::getProductCategoryId, id);
        List<ProductCategorySub> productCategorySubs = productCategorySubService.getBaseMapper().selectList(queryWrapper);
        // 不存在二级分类
        if (productCategorySubs.size() <= 0) {
            // 删除
            boolean res = productCategoryService.removeById(id);
            if (!res) return RespResult.fail("删除商品分类失败");
            // 删除成功，刷新缓存
            productCategoryService.findAndCacheAll();
            return RespResult.success("删除商品分类成功");
        }
        // 存在二级分类
        // 没有传递 toId，不允许删除
        if (Objects.isNull(toId)) return RespResult.fail("该商品分类下存在二级分类，请指定二级分类要转移到的一级分类");
        // 查询 toId 是否存在
        ProductCategory to = productCategoryService.getById(toId);
        if (Objects.isNull(to)) return RespResult.fail("指定的二级分类要转移到的一级分类不存在");
        // 转移商品
        // 所有商品
        List<ProductVo> productVos = productService.findAllFromCache();
        // 查询该二级分类下的商品
        productVos = productVos.stream().filter(productVo -> productVo.getProductCategoryId() == id).toList();
        // 转移商品
        for (ProductVo productVo : productVos) {
            productVo.setProductCategoryId(toId);
            Product product = Convert2PoUtil.genProduct(productVo);
            boolean res = productService.updateById(product);
            if (!res) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("由于商品转移失败，删除商品分类失败");
            }
        }
        // 转移二级分类
        for (ProductCategorySub productCategorySub : productCategorySubs) {
            productCategorySub.setProductCategoryId(toId);
            // 更新数据库
            boolean res = productCategorySubService.updateById(productCategorySub);
            if (!res) {
                // 回滚
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("转移二级分类失败，请稍后重试");
            }
        }
        // 删除商品分类
        boolean res = productCategoryService.removeById(id);
        if (!res) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        ;
        // 删除成功，刷新缓存
        List<ProductCategoryVo> categoryVos = productCategoryService.findAndCacheAll();
        if (Objects.isNull(categoryVos)) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        List<ProductCategoryVo> productCategoryVos = productCategoryService.findAndCacheAllWithImg();
        if (Objects.isNull(productCategoryVos)) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        List<ProductVo> productVos1 = productService.getAllAndCache();
        if (Objects.isNull(productVos1)) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        return RespResult.success("删除商品分类成功，该分类下的二级分类转移成功");
    }

    @Override
    @Transactional
    public RespResult<Object> deleteProductCategorySub(Long id, Long toId, Long toSubId) {
        // 所有商品
        List<ProductVo> productVos = productService.findAllFromCache();
        // 查询该二级分类下的商品
        productVos = productVos.stream().filter(productVo -> productVo.getProductCategorySubId() == id).toList();
        // 转移商品
        for (ProductVo productVo : productVos) {
            productVo.setProductCategoryId(toId);
            productVo.setProductCategorySubId(toSubId);
            Product product = Convert2PoUtil.genProduct(productVo);
            boolean res = productService.updateById(product);
            if (!res) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("由于商品转移失败，删除二级商品分类失败");
            }
        }
        boolean res = productCategorySubService.removeById(id);
        if (!res) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除二级商品分类失败，请稍后重新尝试");
        }
        // 删除成功，刷新缓存
        List<ProductCategoryVo> categoryVos = productCategoryService.findAndCacheAll();
        if (Objects.isNull(categoryVos)) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        List<ProductCategoryVo> productCategoryVos = productCategoryService.findAndCacheAllWithImg();
        if (Objects.isNull(productCategoryVos)) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        List<ProductVo> productVos1 = productService.getAllAndCache();
        if (Objects.isNull(productVos1)) {
            // 回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("删除商品分类失败");
        }
        return RespResult.success("删除二级商品分类成功");
    }

    /**
     * 判断商品一级分类是否可以添加
     *
     * @param productCategory
     * @return
     */
    private RespResult<Object> judgeProductCategoryExists(ProductCategory productCategory) {
        try {
            LambdaQueryWrapper<ProductCategory> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProductCategory::getName, productCategory.getName()).or().eq(ProductCategory::getCode, productCategory.getCode());
            ProductCategory productCategory1 = productCategoryService.getOne(queryWrapper);
            // 不存在，可以添加
            if (Objects.isNull(productCategory1)) return null;
            // 修改的为自己，允许
            if (productCategory.getId() == productCategory1.getId()) return null;
            // 不允许重复添加
            return RespResult.fail("该一级商品分类已经存在，请勿重复录入");
        } catch (Exception e) {
            return RespResult.fail("该一级商品分类已经存在，请勿重复录入");
        }
    }

    /**
     * 判断商品二级分类是否可以添加
     *
     * @param productCategorySub
     * @return
     */
    private RespResult<Object> judgeProductCategorySubExists(ProductCategorySub productCategorySub) {
        try {
            LambdaQueryWrapper<ProductCategorySub> queryWrapper = new LambdaQueryWrapper<>();
            // queryWrapper.eq(ProductCategorySub::getName, productCategorySub.getName())
            //         .or().eq(ProductCategorySub::getCode, productCategorySub.getCode())
            //         .and(i -> i.eq(ProductCategorySub::getProductCategoryId, productCategorySub.getProductCategoryId()));
            queryWrapper.eq(ProductCategorySub::getProductCategoryId, productCategorySub.getProductCategoryId())
                    .and(
                            i -> i.eq(ProductCategorySub::getName, productCategorySub.getName())
                                    .or().eq(ProductCategorySub::getCode, productCategorySub.getCode())
                    );
            ProductCategorySub productCategorySub1 = productCategorySubService.getOne(queryWrapper);
            // 不存在，可以添加
            if (Objects.isNull(productCategorySub1)) return null;
            // 修改的为自己，允许
            if (productCategorySub.getId() == productCategorySub1.getId()) return null;
            // 不允许重复添加
            return RespResult.fail("提交的二级商品分类中 %s 在当前选择的一级分类中已经存在，请勿重复录入".formatted(productCategorySub.getName()));
            // List<ProductCategorySub> productCategorySubs = productCategorySubService.getBaseMapper().selectList(queryWrapper);
            // // 不存在，可以添加
            // if (Objects.isNull(productCategorySubs) || productCategorySubs.size() <= 0) return null;
            // // 修改的为自己，允许
            // if (productCategorySubs.size() == 1 && productCategorySub.getId() == productCategorySubs.get(0).getId()) return null;
            // // 不允许重复添加
            // return RespResult.fail("提交的二级商品分类中 %s 在当前选择的一级分类中已经存在，请勿重复录入".formatted(productCategorySub.getName()));
        } catch (Exception e) {
            return RespResult.fail("提交的二级商品分类中 %s 在当前选择的一级分类中已经存在，请勿重复录入".formatted(productCategorySub.getName()));
        }
    }

    /**
     * 分页获取商品分类
     *
     * @param current
     * @param pageSize
     * @param disabled
     * @param nameMatch
     * @param codeMatch
     * @return
     */
    @Override
    public RespResult<Object> getProductCategoryPage(Integer current, Integer pageSize, Boolean disabled, String nameMatch, String codeMatch) {
        PageResult<List<ProductCategoryVo>> productCategoryVoPage = productCategoryService.findProductCategoryVoPage(current, pageSize, disabled, nameMatch, codeMatch);
        return RespResult.success("获取商品分类列表成功", productCategoryVoPage);
    }

    /**
     * 从缓存中获取全部的商品分类
     *
     * @return
     */
    @Override
    public RespResult<Object> getProductCategoryAll() {
        // 从缓存中获取全部的商品分类
        List<ProductCategoryVo> productCategoryVos = productCategoryService.findAllFromCache();
        if (Objects.isNull(productCategoryVos)) return RespResult.fail("获取商品分类列表失败，请稍后重新尝试");
        return RespResult.success("获取商品分类列表成功", productCategoryVos);
    }

    /**
     * 上传商品
     *
     * @param uploadProductVo
     * @return
     */
    @Override
    @Transactional
    public RespResult<Object> uploadProduct(UploadProductVo uploadProductVo) {
        Product product = Convert2PoUtil.genProduct(uploadProductVo);
        // 更新商品信息
        if (Objects.nonNull(product.getId())) {
            // 删除之前的商品信息（修改商品，删除，重新录入）
            RespResult<Object> respResult = removeProductById(product.getId());
            if (!respResult.getStatus()) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("商品信息提交失败，请稍后重新尝试");
            }
        } else {
            // 更新商品销量
            RespResult<Object> respResult2 = updateAllProductSale();
            if (!respResult2.getStatus()) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("商品信息上传失败，商品销量跟新失败");
            }
        }
        // 判断商品是否存在
        RespResult<Object> respResult = judgeProductExists(product);
        if (Objects.nonNull(respResult)) return respResult;
        // 商品不存在
        // 添加商品
        boolean res = productService.save(product);
        // 失败
        if (!res) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return RespResult.fail("商品信息提交失败，请稍后重新尝试");
        }
        // 商品信息提交成功
        // 商品选项信息
        List<ProductOptions> options = uploadProductVo.getOptions();
        // 提交商品选项信息
        for (ProductOptions option : options) {
            option.setProductId(product.getId());
            // 查询商品选项在同一个商品中是否重复
            RespResult<Object> respResult1 = judgeProductOptionExists(option);
            if (Objects.nonNull(respResult1)) {
                // 回滚
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return respResult1;
            }
            // 添加商品选项
            boolean res1 = productOptionsService.save(option);
            if (!res1) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("商品信息提交失败，请稍后重新尝试");
            }
        }
        // 商品参数信息
        List<ProductParam> params = uploadProductVo.getParams();
        // 提交商品参数信息
        for (ProductParam param : params) {
            param.setProductId(product.getId());
            // 判断在同一个商品中是否存在相同名称的商品参数
            RespResult<Object> respResult1 = judgeProductParamExists(param);
            if (Objects.nonNull(respResult1)) {
                // 回滚
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return respResult1;
            }
            // 添加商品参数
            boolean res1 = productParamService.save(param);
            if (!res1) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("商品信息提交失败，请稍后重新尝试");
            }
        }
        // 商品图片列表
        List<String> imgList = uploadProductVo.getImgList();
        for (String img : imgList) {
            ProductImg productImg = new ProductImg(null, product.getId(), img);
            // 添加商品图片
            boolean res1 = productImgService.save(productImg);
            if (!res1) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("商品信息提交失败，请稍后重新尝试");
            }
        }
        // 商品标签
        List<String> labelNames = uploadProductVo.getLabelNames();
        for (String labelName : labelNames) {
            ProductLabel productLabel = new ProductLabel(null, product.getId(), labelName);
            // 添加商品标签
            boolean res1 = productLabelService.save(productLabel);
            if (!res1) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return RespResult.fail("商品信息提交失败，请稍后重新尝试");
            }
        }
        // 更新缓存
        productService.getAllAndCache();
        productCategoryService.findAndCacheAllWithImg();
        // 全部成功
        return RespResult.success("商品信息提交成功");
    }

    /**
     * 判断商品参数是否存在，同一个商品下，名称一样即视为重复，不允许商品参数名重复
     *
     * @param productParam
     * @return
     */
    private RespResult<Object> judgeProductParamExists(ProductParam productParam) {
        LambdaQueryWrapper<ProductParam> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper
                .eq(ProductParam::getName, productParam.getName())
                .and(i -> i.eq(ProductParam::getProductId, productParam.getProductId()));
        ProductParam productParam1 = productParamService.getOne(queryWrapper);
        if (Objects.isNull(productParam1)) return null;
        if (productParam.getId() == productParam1.getId()) return null;
        return RespResult.fail("商品参数存在重复，请修改后重新提交");
    }

    /**
     * 判断商品选项是否存在，同一个商品下，名称一样即视为重复，不允许商品选项名重复
     *
     * @param productOptions
     * @return null-不存在重复
     */
    private RespResult<Object> judgeProductOptionExists(ProductOptions productOptions) {
        LambdaQueryWrapper<ProductOptions> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper
                .eq(ProductOptions::getName, productOptions.getName())
                .and(i -> i.eq(ProductOptions::getProductId, productOptions.getProductId()));
        ProductOptions productOptions1 = productOptionsService.getOne(queryWrapper);
        if (Objects.isNull(productOptions1)) return null;
        if (productOptions.getId() == productOptions1.getId()) return null;
        return RespResult.fail("商品选项存在重复，请修改后重新提交");
    }

    /**
     * 判断商品是否存在，商品名称一样即视为重复，不允许商品名重复
     *
     * @param product
     * @return null-不存在重复
     */
    private RespResult<Object> judgeProductExists(Product product) {
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
        // queryWrapper.eq(Product::getTitle, product.getTitle());
        // 根据书本编号进行判断
        queryWrapper.eq(Product::getCode, product.getCode());
        Product product1 = productService.getOne(queryWrapper);
        // 不存在重复
        if (Objects.isNull(product1)) return null;
        // 删除了，也不算重复
        // if (product1.getIsRemove()) return null;
        // 同一个，不算重复
        if (product1.getId() == product.getId()) return null;
        return RespResult.fail("该书籍 ISBN 已存在");
    }

}
